Formal aspects of component software (FACS 2010 selected and extended papers)

This issue includes extended versions of selected best papers from the 7th International Workshop on Formal Aspects of Component Software (FACS 2010) held in Guimarães, Portugal on October 14–16, 2010. The component-based software development approach has emerged as a promising paradigm to cope with an ever increasing complexity of present-day software solutions by bringing sound production and engineering principles into software engineering. However, many conceptual and technological issues remain that challenge component-based software development theory and practice. To address these issues, FACS seeks to provide a forum for researchers and practitioners in the areas of component software and formal methods to foster a better understanding of the component-based paradigm and its applications as well as how formal methods can or should be used to make component-based software development succeed

Applications = components + GLoo

We are advocating a component-oriented software development approach that provides support for a clear separation between the computational and the compositional entities of an application. This principle is best captured by the application building paradigm 'Applications = Components + Scripts.' However, the biggest obstacle for a successful use of this maxim originates from the choice of the scripting mechanisms being used to define applications as compositions of reusable software components. In this paper, we analyze GLoo, a novel component-oriented programming framework, which derives its expressive power from an extensible and open-ended scripting language. The design of GLoo aims at a higher-level, scalable, and problem-oriented software development approach, which enables simultaneously both small-scale and large-scale software development through the definition of specially-designed domain sublanguages

Partition refinement of Component Interaction Automata

Component Interaction Automata provide a fitting model to capture and analyze the temporal facets of hierarchically-structured component-oriented software systems. However, the rules governing composition typically suffer from combinatorial state explosion, an effect that can impede modeling languages, like Component Interaction Automata, from being successful in real-world scenarios. We must, therefore, find some appropriate ways to counteract state explosion, one of which is partition refinement through bisimulation, in particular, weak bisimulation. While this technique can yield the desired state space reduction, it does not consider synchronization cliques, that is, groups of states that are interconnected solely by internal synchronization transitions. Synchronization cliques give rise to action prefixes, local states that encapsulate pre-conditions for a component's ability to interact with the environment. Furthermore, both the existence and the size of synchronization cliques can be used as an indicator for the success of partition refinement. In particular, the more frequent synchronization cliques are and the more states they entail, the more likely it is that partition refinement can reduce the state space. But, there may be other factors that impact the refinement process. For this reason, we study, in this paper, how partition refinement behaves under weak bisimulation, how synchronization cliques emerge when using weak bisimulation, how we make state space reduction through partition refinement aware of the existence of synchronization cliques, and what other attributes of Component Interaction Automata specifications can provides us with additional cues to forecast the possible outcome of the partition refinement process

Using metadata transformations to integrate class extensions in an existing class hierarchy

Class extensions provide a fine-grained mechanism to define incremental modifications to class-based systems when standard subclassing mechanisms are inappropriate. To control the impact of class extensions, the concept of classboxes has emerged that defines a new module system to restrict the visibility of class extensions to selected clients. However, the existing implementations of the classbox concept rely either on a 'classbox- aware' virtual machine, an expensive runtime introspection of the method call stack to build the structure of a classbox, or both. In this paper we present an implementation technique that allows for the structure of a classbox to be constructed at compile-time by means of metadata transformations to rewire the inheritance graph of refined classes. These metadata transformations are language-neutral and more importantly preserve both the semantics of the classbox concept and the integrity of the underlying deployment units. As a result, metadata transformation provides a feasible approach to incorporate the classbox concept into programming environments that use a virtual execution system

A Pi-Calculus Based Approach to Software Composition

Present-day applications are increasingly required to be flexible, or "open" in a variety of ways. By flexibility we mean that these applications have to be portable (to different hardware and software platforms), interoperable (with other applications), extendible (to new functionality), configurable (to individual users' or clients' needs), and maintainable. These kinds of flexibility are currently best supported by component-oriented software technology: components, by means of abstraction, support portability, interoperability, and maintainability. Extendibility and configurability are supported by different forms of binding technology, or "glue": application parts, or even whole applications can be created by composing software components; applications stay flexible by allowing components to be replaced or reconfigured, possibly at runtime. This thesis develops a formal language for software composition that is based on the Pi-calculus. More precisely, we present the L-calculus, a variant of the Pi-calculus in which agents communicate by passing extensible, labeled records, or so-called "forms", rather than tuples. This approach makes it much easier to model compositional abstractions than it is possible in the plain Pi-calculus, since the contents of communication are now independent of position, agents are more naturally polymorphic since communication forms can be easily extended, and environmental arguments can be passed implicitly. The L-calculus is developed in three stages: (i) we analyse whether the Pi-calculus is suitable to model composition abstractions, (ii) driven by the insights we got using the Pi-calculus, we de ne a new calculus that has better support for software composition (e.g., provides support for inherently extensible software construction), and (iii), we de ne a first-order type system with subtype polymorphism and sound record concatenation that allows us to check statically an agent system in order to prevent the occurrences of run-time errors. We conclude with defining a first Java-based composition system and Piccola, a prototype composition language based on the L-calculus. The composition system provides support for integrating arbitrary compositional abstractions using both Piccola and standard bridging technologies like RMI and CORBA. Furthermore, the composition systems maintains a composition library that provides components in a uniform way

Capturing generalized recurring system attributes (STEM Blitz February 2015)

Full title: Capturing generalized recurring system attributes with specification patterns. Property specification patterns equipped with a natural language front-end and automated mapping support for a temporal logic of choice offer a solution to overcome the pragmatic barriers to specify system properties in a purely mathematical fashion. Recorded on 13 February 2015

A Lambda Calculus With Forms

Abstract. The need to use position-dependent parameters often hampers the definition of flexible, extensible, and reusable abstractions for software composition. This observation has led us to explore the concept of forms, which are first-class extensible records and that, in combination with a small set of purely asymmetric operators, provide a core language to address this issue. One interesting application of forms is the definition of contractual specifications to ensure that a component can be safely combined with other components or deployed in a new context. In fact, contractual specifications explicitly and formally state what a component offers without entering into the details of how. In this paper, we develop a formal form-based framework for the definition of contractual specifications. More precisely, we study a substitution-free variant of the lambda-calculus, called λF, where names are replaced with forms and parameter passing is modeled using explicit contexts and show how the λF-calculus can be used to define syntactic contractual specifications.

A Form-based Framework for Class Extensions

Class extensions allow for a modular addition of new behavior to an existing class hierarchy. However, the reliance on position-dependent parameters in mainstream programming languages has often a negative impact on the way new behavior can be specified. This observation has led us to explore the concept of forms, which are first-class extensible records that, in combination with a small set of purely asymmetric operators, provide a core language for an extensible, flexible, and robust software development approach. In this paper, we present a refinement of our recent work on a substitution-free lambda calculus with forms. More precisely, we develop the λF@-calculus in which names are replaced with shared forms and parameter passing is modeled using explicit contexts and show, how this calculus can be used to model open classes, a key mechanism for class extensions.</p